<?xml version='1.0' encoding='iso-8859-1'?>
<!doctype html public '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
<html xmlns='http://www.w3c.org/1999/xhtml' lang='en-us'>
	<head>
		<title>
			readpacket.c
			</title>
		<meta http-equiv='content-type' content='text/html;iso-8859-1'/>
		<meta name='generator' content='motley-tools 1.9.4 13:40:33 Feb 18 2015'/>
		<meta name='author' content='cmaier@cmassoc.net'/>
		<meta name='robots' content='noindex,nofollow'/>
		<link href='toolkit.css' rel='stylesheet' type='text/css'/>
		</head>
	<body>
		<div class='headerlink'>
			[<a href='ReadNVM.c.html' title=' ReadNVM.c '>PREV</a>]
			[<a href='toolkit.html' title=' Index '>HOME</a>]
			[<a href='ReadParameterBlock.c.html' title=' ReadParameterBlock.c '>NEXT</a>]
			</div>
<pre>
/*====================================================================*
 *
 *   Copyright (c) 2013 Qualcomm Atheros, Inc.
 *
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or 
 *   without modification, are permitted (subject to the limitations 
 *   in the disclaimer below) provided that the following conditions 
 *   are met:
 *
 *   * Redistributions of source code must retain the above copyright 
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the following 
 *     disclaimer in the documentation and/or other materials 
 *     provided with the distribution.
 *
 *   * Neither the name of Qualcomm Atheros nor the names of 
 *     its contributors may be used to endorse or promote products 
 *     derived from this software without specific prior written 
 *     permission.
 *
 *   NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE 
 *   GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE 
 *   COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR 
 *   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
 *   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 *   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
 *   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
 *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 *   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
 *   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
 *
 *--------------------------------------------------------------------*/

/*====================================================================*
 *
 *   ssize_t readpacket (struct channel const * channel, void * memory, ssize_t extent);
 *
 *   channel.h
 *
 *   read one packet from a raw packet channel;
 *
 *   return the packet size on success, 0 on timeout or -1 on error;
 *   dump packets on stdout when the channel VERBOSE flag is set;
 *
 *   constant __MAGIC__ enables code that reads frames from stdin,
 *   instead of the network; you may use it whenever a network or
 *   transmitting device is not available;
 *
 *
 *   Contributor(s):
 *	Charles Maier &lt;cmaier@qca.qualcomm.com&gt;
 *	Nathaniel Houghton &lt;nhoughto@qca.qualcomm.com&gt;
 *      Werner Henze &lt;w.henze@avm.de&gt;
 *
 *--------------------------------------------------------------------*/

#ifndef READPACKET_SOURCE
#define READPACKET_SOURCE

#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;
#include &lt;memory.h&gt;
#include &lt;errno.h&gt;

#include &quot;../ether/channel.h&quot;
#include &quot;../tools/memory.h&quot;
#include &quot;../tools/error.h&quot;
#include &quot;../tools/flags.h&quot;

#if defined (__MAGIC__)
#include &quot;../tools/hexload.c&quot;
#endif

ssize_t readpacket (struct channel const * channel, void * memory, ssize_t extent)

{

#if defined (__MAGIC__)

	memset (memory, 0, extent);
	extent = hexload (memory, extent, stdin);
	if (_anyset (channel-&gt;flags, CHANNEL_VERBOSE))
	{
		hexdump (memory, 0, extent, stdout);
	}
	return (extent);

#elif defined (__linux__)

#include &lt;sys/poll.h&gt;

	struct pollfd pollfd =
	{
		channel-&gt;fd,
		POLLIN,
		0
	};
	signed status = poll (&amp;pollfd, 1, channel-&gt;capture);
	memset (memory, 0, extent);
	if ((status &lt; 0) &amp;&amp; (errno != EINTR))
	{
		error (0, errno, &quot;%s can't poll %s&quot;, __func__, channel-&gt;ifname);
		return (-1);
	}
	if (status &gt; 0)
	{
		status = recvfrom (channel-&gt;fd, memory, extent, 0, (struct sockaddr *) (0), (socklen_t *)(0));
		if (status &lt; 0)
		{
			error (0, errno, &quot;%s can't read %s&quot;, __func__, channel-&gt;ifname);
			return (-1);
		}
		if (status &gt; 0)
		{
			extent = status;
			if (_anyset (channel-&gt;flags, CHANNEL_VERBOSE))
			{
				hexdump (memory, 0, extent, stdout);
			}
			return (extent);
		}
	}

#elif defined (__APPLE__) || defined (__OpenBSD__)

	struct bpf_hdr * bpf_packet;
	struct bpf * bpf = channel-&gt;bpf;;
	memset (memory, 0, extent);
	if (bpf-&gt;bpf_bufused &lt;= 0)
	{
		bpf-&gt;bpf_bufused = read (channel-&gt;fd, bpf-&gt;bpf_buffer, bpf-&gt;bpf_length);
		bpf-&gt;bpf_bp = bpf-&gt;bpf_buffer;
	}
	if (bpf-&gt;bpf_bufused &lt; 0)
	{
		error (0, errno, &quot;bpf&quot;);
		return (-1);
	}
	if (bpf-&gt;bpf_bufused &gt; 0)
	{
		bpf_packet = (struct bpf_hdr *)(bpf-&gt;bpf_bp);
		if ((size_t) (extent) &gt; bpf_packet-&gt;bh_caplen)
		{
			extent = bpf_packet-&gt;bh_caplen;
		}
		if ((size_t) (extent) &lt; bpf_packet-&gt;bh_caplen)
		{ 
			if (_anyset (channel-&gt;flags, CHANNEL_VERBOSE)) 
			{
				error (0, 0, &quot;Truncated incoming frame (%u -&gt; %zd bytes)&quot;, bpf_packet-&gt;bh_caplen, extent); 
			}
		}
		memcpy (memory, bpf-&gt;bpf_bp + bpf_packet-&gt;bh_hdrlen, extent);
		bpf-&gt;bpf_bufused -= BPF_WORDALIGN (bpf_packet-&gt;bh_hdrlen + bpf_packet-&gt;bh_caplen);
		bpf-&gt;bpf_bp += BPF_WORDALIGN (bpf_packet-&gt;bh_hdrlen + bpf_packet-&gt;bh_caplen);
		if (_anyset (channel-&gt;flags, CHANNEL_VERBOSE))
		{
			hexdump (memory, 0, extent, stdout);
		}
		return (extent);
	}

#elif defined (WINPCAP) || defined (LIBPCAP)

	struct pcap_pkthdr * header;
	const uint8_t *data;
	signed status = pcap_next_ex (channel-&gt;socket, &amp;header, &amp;data);
	memset (memory, 0, extent);
	if (status &lt; 0)
	{
		error (0, errno, &quot;pcap_next_ex&quot;);
		return (-1);
	}
	if (status &gt; 0)
	{
		extent = header-&gt;caplen;
		memcpy (memory, data, extent);
		if (_anyset (channel-&gt;flags, CHANNEL_VERBOSE))
		{
			hexdump (memory, 0, extent, stdout);
		}
		return (extent);
	}

#else
#error &quot;Unknown Environment&quot;
#endif

	return (0);
}

#endif


</pre>
		<div class='footerlink'>
			[<a href='ReadNVM.c.html' title=' ReadNVM.c '>PREV</a>]
			[<a href='toolkit.html' title=' Index '>HOME</a>]
			[<a href='ReadParameterBlock.c.html' title=' ReadParameterBlock.c '>NEXT</a>]
			</div>
		</body>
	</html>
